<!DOCTYPE html>
<html lang="zh-CN">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Python入门教程 - 从零开始学编程</title>
    <link rel="stylesheet" href="https://cdnjs.cloudflare.com/ajax/libs/font-awesome/6.0.0-beta3/css/all.min.css">
    <style>
        :root {
            --primary-color: #3776ab;
            --secondary-color: #ffd43b;
            --text-color: #333;
            --light-bg: #f8f9fa;
            --code-bg: #f4f4f4;
            --border-color: #ddd;
            --success-color: #28a745;
            --error-color: #dc3545;
            --sidebar-width: 250px;
            --sidebar-collapsed-width: 50px;
        }

        * {
            margin: 0;
            padding: 0;
            box-sizing: border-box;
        }

        body {
            font-family: 'Segoe UI', Tahoma, Geneva, Verdana, sans-serif;
            line-height: 1.6;
            color: var(--text-color);
            background-color: #fff;
        }

        .container {
            max-width: 1200px;
            margin: 0 auto;
            padding: 0 20px;
        }

        header {
            background-color: var(--primary-color);
            color: white;
            padding: 1rem 0;
            box-shadow: 0 2px 5px rgba(0,0,0,0.1);
            position: sticky;
            top: 0;
            z-index: 100;
        }

        .header-content {
            display: flex;
            justify-content: space-between;
            align-items: center;
            position: relative;
        }

        .logo {
            display: flex;
            align-items: center;
            font-size: 1.5rem;
            font-weight: bold;
            flex: 1;
        }

        .logo i {
            margin-right: 10px;
            color: var(--secondary-color);
        }

        .author-info {
            font-size: 0.9rem;
            opacity: 0.9;
        }

        .menu-toggle {
            display: none;
            background: none;
            border: none;
            color: white;
            font-size: 1.5rem;
            cursor: pointer;
        }

        .hero {
            background: linear-gradient(135deg, var(--primary-color), #2c5aa0);
            color: white;
            padding: 4rem 0;
            text-align: center;
            margin-left: var(--sidebar-width); /* 添加左边距，等于侧边栏宽度 */
            transition: margin-left 0.3s; /* 添加过渡效果 */
        }

        .hero h1 {
            font-size: 2.5rem;
            margin-bottom: 1rem;
        }

        .hero p {
            font-size: 1.2rem;
            max-width: 800px;
            margin: 0 auto 2rem;
        }

        .btn {
            display: inline-block;
            background-color: var(--secondary-color);
            color: var(--primary-color);
            padding: 0.8rem 1.5rem;
            border-radius: 5px;
            text-decoration: none;
            font-weight: bold;
            transition: all 0.3s;
            border: none;
            cursor: pointer;
        }

        .btn:hover {
            background-color: white;
            color: var(--primary-color);
        }

        .sidebar {
            position: fixed;
            top: 80px;
            left: 0;
            width: var(--sidebar-width);
            height: calc(100vh - 80px);
            background-color: var(--light-bg);
            overflow-y: auto;
            padding: 20px;
            border-right: 1px solid var(--border-color);
            transition: width 0.3s, padding 0.3s;
            z-index: 50;
        }

        .sidebar.collapsed {
            width: var(--sidebar-collapsed-width);
            padding: 20px 10px;
        }

        .sidebar-toggle {
            position: absolute;
            top: 15px;
            right: 10px;
            background-color: var(--primary-color);
            color: white;
            border: none;
            border-radius: 50%;
            width: 30px;
            height: 30px;
            display: flex;
            align-items: center;
            justify-content: center;
            cursor: pointer;
            z-index: 10;
            box-shadow: 0 2px 5px rgba(0,0,0,0.2);
            overflow: visible; /* 确保按钮内容完整显示 */
        }

        .sidebar h3 {
            margin-bottom: 15px;
            color: var(--primary-color);
            white-space: nowrap;
            overflow: hidden;
            text-overflow: ellipsis;
        }

        .sidebar.collapsed h3 {
            display: none;
        }

        .sidebar ul {
            list-style: none;
        }

        .sidebar ul li {
            margin-bottom: 10px;
        }

        .sidebar ul li a {
            color: var(--text-color);
            text-decoration: none;
            display: block;
            padding: 8px 10px;
            border-radius: 4px;
            transition: all 0.3s;
            white-space: nowrap;
            overflow: hidden;
            text-overflow: ellipsis;
        }

        .sidebar.collapsed ul li a {
            padding: 8px 0;
            text-align: center;
        }

        .sidebar.collapsed ul li a span {
            display: none;
        }

        .sidebar ul li a:hover,
        .sidebar ul li a.active {
            background-color: var(--primary-color);
            color: white;
        }

        .sidebar ul ul {
            margin-left: 15px;
            margin-top: 5px;
        }

        .sidebar.collapsed ul ul {
            display: none;
        }

        .sidebar ul ul li a {
            font-size: 0.9rem;
            padding: 5px 8px;
        }

        .content {
            margin-left: var(--sidebar-width);
            padding: 2rem;
            min-height: calc(100vh - 80px);
            transition: margin-left 0.3s;
            padding-left: calc(2rem + 20px); /* 增加左侧内边距，防止内容被导航栏遮挡 */
        }

        .content.expanded {
            margin-left: var(--sidebar-collapsed-width); /* 折叠时的左边距 */
        }

        .hero {
            background: linear-gradient(135deg, var(--primary-color), #2c5aa0);
            color: white;
            padding: 4rem 0;
            text-align: center;
            margin-left: var(--sidebar-width); /* 添加左边距，等于侧边栏宽度 */
            transition: margin-left 0.3s; /* 添加过渡效果 */
        }

        .hero.expanded {
            margin-left: var(--sidebar-collapsed-width); /* 折叠时的左边距 */
        }

        .section {
            margin-bottom: 3rem;
        }

        .section h2 {
            color: var(--primary-color);
            margin-bottom: 1rem;
            padding-bottom: 0.5rem;
            border-bottom: 2px solid var(--secondary-color);
        }

        .section h3 {
            color: var(--primary-color);
            margin: 1.5rem 0 1rem;
        }

        .code-block {
            background-color: var(--code-bg);
            border: 1px solid var(--border-color);
            border-radius: 5px;
            padding: 15px;
            margin: 1rem 0;
            position: relative;
            overflow-x: auto;
        }

        .code-block pre {
            margin: 0;
            font-family: 'Consolas', 'Monaco', monospace;
            font-size: 0.9rem;
            line-height: 1.4;
        }

        .copy-btn {
            position: absolute;
            top: 10px;
            right: 10px;
            background-color: var(--primary-color);
            color: white;
            border: none;
            border-radius: 3px;
            padding: 5px 10px;
            font-size: 0.8rem;
            cursor: pointer;
            transition: background-color 0.3s;
        }

        .copy-btn:hover {
            background-color: #2c5aa0;
        }

        .copy-btn.copied {
            background-color: var(--success-color);
        }

        .quiz {
            background-color: var(--light-bg);
            border: 1px solid var(--border-color);
            border-radius: 5px;
            padding: 20px;
            margin: 2rem 0;
        }

        .quiz h3 {
            margin-bottom: 15px;
            color: var(--primary-color);
        }

        .quiz-question {
            margin-bottom: 15px;
            font-weight: bold;
        }

        .quiz-options {
            margin-bottom: 15px;
        }

        .quiz-option {
            display: block;
            margin-bottom: 8px;
        }

        .quiz-option input {
            margin-right: 10px;
        }

        .quiz-feedback {
            padding: 10px;
            border-radius: 4px;
            margin-top: 10px;
            display: none;
        }

        .quiz-feedback.correct {
            background-color: rgba(40, 167, 69, 0.2);
            color: var(--success-color);
            border: 1px solid var(--success-color);
        }

        .quiz-feedback.incorrect {
            background-color: rgba(220, 53, 69, 0.2);
            color: var(--error-color);
            border: 1px solid var(--error-color);
        }
        
        .search-container {
            position: relative;
            margin-left: 20px;
            width: 300px;
            display: flex;
            align-items: center;
        }
        
        .search-input-wrapper {
            position: relative;
            flex: 1;
        }
        
        .search-input {
            width: 100%;
            padding: 8px 35px 8px 10px;
            border: 1px solid rgba(255, 255, 255, 0.3);
            border-radius: 20px;
            background-color: rgba(255, 255, 255, 0.1);
            color: white;
            font-size: 0.9rem;
            transition: all 0.3s;
        }
        
        .search-input::placeholder {
            color: rgba(255, 255, 255, 0.7);
        }
        
        .search-input:focus {
            outline: none;
            border-color: rgba(255, 255, 255, 0.5);
            background-color: rgba(255, 255, 255, 0.2);
        }
        
        .search-icon {
            position: absolute;
            right: 10px;
            top: 50%;
            transform: translateY(-50%);
            color: rgba(255, 255, 255, 0.7);
        }
        
        .search-nav {
            display: none;
            margin-left: 10px;
        }
        
        .search-nav.active {
            display: flex;
        }
        
        .search-nav button {
            background: none;
            border: none;
            color: white;
            cursor: pointer;
            padding: 5px;
            margin: 0 2px;
            border-radius: 3px;
            transition: background-color 0.3s;
        }
        
        .search-nav button:hover {
            background-color: rgba(255, 255, 255, 0.2);
        }
        
        .search-nav button:disabled {
            opacity: 0.5;
            cursor: not-allowed;
        }
        
        .search-results-count {
            color: rgba(255, 255, 255, 0.9);
            font-size: 0.8rem;
            margin: 0 5px;
            white-space: nowrap;
        }
        
        .quiz-feedback.incorrect {
            background-color: rgba(220, 53, 69, 0.2);
            color: var(--error-color);
            border: 1px solid var(--error-color);
        }
        
        mark.highlight {
            background-color: yellow;
            color: black;
            padding: 0;
        }
        
        mark.current-search-result {
            background-color: orange;
            color: black;
            padding: 0;
            box-shadow: 0 0 5px rgba(255, 165, 0, 0.7);
        }

        .note {
            background-color: rgba(255, 212, 59, 0.2);
            border-left: 4px solid var(--secondary-color);
            padding: 10px 15px;
            margin: 1rem 0;
        }

        .tip {
            background-color: rgba(55, 118, 171, 0.2);
            border-left: 4px solid var(--primary-color);
            padding: 10px 15px;
            margin: 1rem 0;
        }

        footer {
            background-color: var(--primary-color);
            color: white;
            text-align: center;
            padding: 1.5rem 0;
            margin-top: 2rem;
        }

        .footer-content {
            display: flex;
            justify-content: space-between;
            align-items: center;
            flex-wrap: wrap;
        }

        .footer-content > div:first-child {
            text-align: right;
            width: 100%;
        }


        .footer-links {
            display: flex;
            list-style: none;
        }

        .footer-links li {
            margin-left: 20px;
        }

        .footer-links a {
            color: white;
            text-decoration: none;
            transition: color 0.3s;
        }

        .footer-links a:hover {
            color: var(--secondary-color);
        }

        @media (max-width: 992px) {
            .sidebar {
                transform: translateX(-100%);
                width: var(--sidebar-width);
            }

            .sidebar.active {
                transform: translateX(0);
            }

            .sidebar.collapsed {
                transform: translateX(-100%);
            }

            .content {
                margin-left: 0;
                padding-left: 2rem; /* 移动设备上恢复正常内边距 */
            }

            .content.expanded {
                margin-left: 0;
                padding-left: 2rem; /* 移动设备上展开时也恢复正常内边距 */
            }
            
            .hero {
                margin-left: 0; /* 移动设备上移除左边距 */
            }
            
            .hero.expanded {
                margin-left: 0; /* 移动设备上展开时也移除左边距 */
            }

            .menu-toggle {
                display: block;
            }

            .nav-overlay {
                position: fixed;
                top: 0;
                left: 0;
                width: 100%;
                height: 100%;
                background-color: rgba(0, 0, 0, 0.5);
                z-index: 40;
                display: none;
            }

            .nav-overlay.active {
                display: block;
            }
        }

        .hero.expanded {
                margin-left: 0; /* 移动设备上展开时也移除左边距 */
            }
            .hero h1 {
                font-size: 2rem;
            }

            .hero p {
                font-size: 1rem;
            }

            .footer-content {
                flex-direction: column;
                text-align: center;
            }

            .footer-links {
                margin-top: 15px;
            }

            .footer-links li {
                margin: 0 10px;
            }
        }
    </style>
</head>
<body>
    <header>
        <div class="container">
            <div class="header-content">
                <button class="menu-toggle" id="menuToggle">
                    <i class="fas fa-bars"></i>
                </button>
                <div class="logo">
                    <i class="fab fa-python"></i>
                    <div>
                        <span>Python入门教程</span>
                        <div class="author-info">作者：levi_jia | 珠海科技学院 电子设计协会</div>
                    </div>
                </div>
                <div class="search-container">
                    <div class="search-input-wrapper">
                        <input type="text" class="search-input" id="searchInput" placeholder="搜索教程内容...">
                        <i class="fas fa-search search-icon"></i>
                    </div>
                    <div class="search-nav" id="searchNav">
                        <button id="prevResult" title="上一个结果">
                            <i class="fas fa-chevron-up"></i>
                        </button>
                        <span class="search-results-count" id="searchResultsCount">0/0</span>
                        <button id="nextResult" title="下一个结果">
                            <i class="fas fa-chevron-down"></i>
                        </button>
                    </div>
                </div>
            </div>
        </div>
    </header>


    <div class="nav-overlay" id="navOverlay"></div>

    <section class="hero">
        <div class="container">
            <h1>从零开始学习Python编程</h1>
            <p>这是一份专为初学者设计的Python入门教程，通过简单易懂的讲解和丰富的实例，帮助你快速掌握Python编程基础。</p>
            <a href="#intro" class="btn">开始学习</a>
        </div>
    </section>

    <div class="sidebar" id="sidebar">
        <button class="sidebar-toggle" id="sidebarToggle">
            <i class="fas fa-chevron-left"></i>
        </button>
        <h3>教程目录</h3>
        <ul>
            <li>
                <a href="#intro" class="active"><span>Python简介</span></a>
            </li>
            <li>
                <a href="#installation"><span>安装与环境配置</span></a>
            </li>
            <li>
                <a href="#basics"><span>Python基础</span></a>
                <ul>
                    <li><a href="#variables"><span>变量与数据类型</span></a></li>
                    <li><a href="#operators"><span>运算符</span></a></li>
                    <li><a href="#strings"><span>字符串操作</span></a></li>
                </ul>
            </li>
            <li>
                <a href="#control-flow"><span>控制流</span></a>
                <ul>
                    <li><a href="#conditionals"><span>条件语句</span></a></li>
                    <li><a href="#loops"><span>循环语句</span></a></li>
                </ul>
            </li>
            <li>
                <a href="#data-structures"><span>数据结构</span></a>
                <ul>
                    <li><a href="#lists"><span>列表</span></a></li>
                    <li><a href="#tuples"><span>元组</span></a></li>
                    <li><a href="#dictionaries"><span>字典</span></a></li>
                    <li><a href="#sets"><span>集合</span></a></li>
                </ul>
            </li>
            <li>
                <a href="#functions"><span>函数</span></a>
            </li>
            <li>
                <a href="#modules"><span>模块与包</span></a>
            </li>
            <li>
                <a href="#file-io"><span>文件操作</span></a>
            </li>
            <li>
                <a href="#exceptions"><span>异常处理</span></a>
            </li>
            <li>
                <a href="#oop"><span>面向对象编程</span></a>
            </li>
        </ul>
    </div>

    <div class="content" id="content">
        <section id="intro" class="section">
            <h2>Python简介</h2>
            <p>Python是一种高级编程语言，由吉多·范罗苏姆（Guido van Rossum）于1991年创建。它以其简洁的语法和强大的功能而闻名，被广泛应用于Web开发、数据分析、人工智能、科学计算等领域。</p>
            
            <h3>为什么选择Python？</h3>
            <ul>
                <li><strong>简单易学</strong>：Python语法简洁明了，接近自然语言，非常适合编程初学者。</li>
                <li><strong>功能强大</strong>：拥有丰富的标准库和第三方库，可以轻松实现各种功能。</li>
                <li><strong>跨平台</strong>：Python可以在Windows、Mac、Linux等多种操作系统上运行。</li>
                <li><strong>应用广泛</strong>：从网站开发到数据分析，从人工智能到自动化脚本，Python无处不在。</li>
            </ul>

            <div class="note">
                <p><strong>提示：</strong>Python的名字来源于英国喜剧团体"Monty Python"，而不是蟒蛇。</p>
            </div>

            <div class="quiz">
                <h3>小测验</h3>
                <div class="quiz-question">Python是由谁创建的？</div>
                <div class="quiz-options">
                    <label class="quiz-option">
                        <input type="radio" name="q1" value="a">
                        a. 詹姆斯·高斯林
                    </label>
                    <label class="quiz-option">
                        <input type="radio" name="q1" value="b">
                        b. 吉多·范罗苏姆
                    </label>
                    <label class="quiz-option">
                        <input type="radio" name="q1" value="c">
                        c. 林纳斯·托瓦兹
                    </label>
                    <label class="quiz-option">
                        <input type="radio" name="q1" value="d">
                        d. 丹尼斯·里奇
                    </label>
                </div>
                <button class="btn" onclick="checkAnswer('q1', 'b')">检查答案</button>
                <div class="quiz-feedback" id="q1-feedback"></div>
            </div>
        </section>

        <section id="installation" class="section">
            <h2>安装与环境配置</h2>
            <p>在开始学习Python之前，你需要在你的计算机上安装Python。以下是安装步骤：</p>
            
            <h3>1. 下载Python</h3>
            <p>访问Python官方网站 <a href="https://www.python.org/downloads/" target="_blank">https://www.python.org/downloads/</a> 下载最新版本的Python。</p>
            
            <h3>2. 安装Python</h3>
            <p>运行下载的安装程序，在安装过程中，请确保勾选"Add Python to PATH"选项，这将使你能够在命令行中直接使用Python。</p>
            
            <h3>3. 验证安装</h3>
            <p>打开命令行工具（Windows上的命令提示符或PowerShell，Mac或Linux上的终端），输入以下命令：</p>
            
            <div class="code-block">
                <button class="copy-btn" onclick="copyCode(this)">复制</button>
                <pre>python --version</pre>
            </div>
            
            <p>如果安装成功，你将看到安装的Python版本号。</p>
            
            <h3>4. 选择代码编辑器</h3>
            <p>虽然你可以使用任何文本编辑器编写Python代码，但使用专门的代码编辑器可以提高效率。以下是一些流行的选择：</p>
            <ul>
                <li><strong>Visual Studio Code</strong>：免费、功能强大，有丰富的插件。</li>
                <li><strong>PyCharm</strong>：专为Python开发的集成开发环境（IDE）。</li>
                <li><strong>Jupyter Notebook</strong>：适合数据分析和科学计算。</li>
            </ul>

            <div class="tip">
                <p><strong>提示：</strong>对于初学者，推荐使用Visual Studio Code，它轻量级且易于使用。</p>
            </div>
        </section>

        <section id="basics" class="section">
            <h2>Python基础</h2>
            
            <div id="variables">
                <h3>变量与数据类型</h3>
                <p>在Python中，变量是用来存储数据的容器。你可以把变量想象成一个标签，它指向内存中的某个值。</p>
                
                <h4>创建变量</h4>
                <p>在Python中创建变量非常简单，只需给变量赋值即可：</p>
                
                <div class="code-block">
                    <button class="copy-btn" onclick="copyCode(this)">复制</button>
                    <pre># 创建变量并赋值
name = "小明"
age = 25
height = 1.75
is_student = True</pre>
                </div>
                
                <h4>Python的基本数据类型</h4>
                <ul>
                    <li><strong>整数（int）</strong>：表示整数，如 10, -5, 0</li>
                    <li><strong>浮点数（float）</strong>：表示小数，如 3.14, -0.5, 2.0</li>
                    <li><strong>字符串（str）</strong>：表示文本，如 "Hello", 'Python'</li>
                    <li><strong>布尔值（bool）</strong>：表示真或假，只有两个值：True 和 False</li>
                </ul>
                
                <h4>查看变量类型</h4>
                <p>使用type()函数可以查看变量的数据类型：</p>
                
                <div class="code-block">
                    <button class="copy-btn" onclick="copyCode(this)">复制</button>
                    <pre>name = "小明"
age = 25
height = 1.75
is_student = True

print(type(name))    # &lt;class 'str'&gt;
print(type(age))     # &lt;class 'int'&gt;
print(type(height))  # &lt;class 'float'&gt;
print(type(is_student))  # &lt;class 'bool'&gt;</pre>
                </div>

                <div class="quiz">
                    <h3>小测验</h3>
                    <div class="quiz-question">以下哪个是Python中的浮点数？</div>
                    <div class="quiz-options">
                        <label class="quiz-option">
                            <input type="radio" name="q2" value="a">
                            a. "3.14"
                        </label>
                        <label class="quiz-option">
                            <input type="radio" name="q2" value="b">
                            b. 3.14
                        </label>
                        <label class="quiz-option">
                            <input type="radio" name="q2" value="c">
                            c. 314
                        </label>
                        <label class="quiz-option">
                            <input type="radio" name="q2" value="d">
                            d. '3.14'
                        </label>
                    </div>
                    <button class="btn" onclick="checkAnswer('q2', 'b')">检查答案</button>
                    <div class="quiz-feedback" id="q2-feedback"></div>
                </div>
            </div>
            
            <div id="operators">
                <h3>运算符</h3>
                <p>Python支持多种运算符，用于执行各种数学和逻辑运算。</p>
                
                <h4>算术运算符</h4>
                <ul>
                    <li><strong>+</strong>：加法</li>
                    <li><strong>-</strong>：减法</li>
                    <li><strong>*</strong>：乘法</li>
                    <li><strong>/</strong>：除法</li>
                    <li><strong>%</strong>：取模（求余数）</li>
                    <li><strong>**</strong>：幂运算</li>
                    <li><strong>//</strong>：整除</li>
                </ul>
                
                <div class="code-block">
                    <button class="copy-btn" onclick="copyCode(this)">复制</button>
                    <pre># 算术运算符示例
a = 10
b = 3

print(a + b)   # 13
print(a - b)   # 7
print(a * b)   # 30
print(a / b)   # 3.333...
print(a % b)   # 1
print(a ** b)  # 1000
print(a // b)  # 3</pre>
                </div>
                
                <h4>比较运算符</h4>
                <ul>
                    <li><strong>==</strong>：等于</li>
                    <li><strong>!=</strong>：不等于</li>
                    <li><strong>></strong>：大于</li>
                    <li><strong><</strong>：小于</li>
                    <li><strong>>=</strong>：大于等于</li>
                    <li><strong><=</strong>：小于等于</li>
                </ul>
                
                <div class="code-block">
                    <button class="copy-btn" onclick="copyCode(this)">复制</button>
                    <pre># 比较运算符示例
a = 10
b = 20

print(a == b)  # False
print(a != b)  # True
print(a > b)   # False
print(a < b)   # True
print(a >= b)  # False
print(a <= b)  # True</pre>
                </div>
                
                <h4>逻辑运算符</h4>
                <ul>
                    <li><strong>and</strong>：逻辑与</li>
                    <li><strong>or</strong>：逻辑或</li>
                    <li><strong>not</strong>：逻辑非</li>
                </ul>
                
                <div class="code-block">
                    <button class="copy-btn" onclick="copyCode(this)">复制</button>
                    <pre># 逻辑运算符示例
a = True
b = False

print(a and b)  # False
print(a or b)   # True
print(not a)    # False</pre>
                </div>
            </div>
            
            <div id="strings">
                <h3>字符串操作</h3>
                <p>字符串是Python中最常用的数据类型之一。在Python中，字符串可以用单引号(')、双引号(")或三引号('''或""")表示。</p>
                
                <h4>创建字符串</h4>
                <div class="code-block">
                    <button class="copy-btn" onclick="copyCode(this)">复制</button>
                    <pre># 创建字符串
str1 = 'Hello, World!'
str2 = "Python编程"
str3 = """这是一个
多行字符串"""</pre>
                </div>
                
                <h4>字符串拼接</h4>
                <p>可以使用+运算符或f-string来拼接字符串：</p>
                
                <div class="code-block">
                    <button class="copy-btn" onclick="copyCode(this)">复制</button>
                    <pre># 字符串拼接
first_name = "张"
last_name = "三"

# 使用+运算符
full_name = first_name + last_name
print(full_name)  # 张三

# 使用f-string（推荐）
full_name = f"{first_name}{last_name}"
print(full_name)  # 张三

# 带格式的f-string
age = 25
intro = f"我叫{first_name}{last_name}，今年{age}岁。"
print(intro)  # 我叫张三，今年25岁。</pre>
                </div>
                
                <h4>字符串方法</h4>
                <p>Python提供了许多内置的字符串方法，用于处理字符串：</p>
                
                <div class="code-block">
                    <button class="copy-btn" onclick="copyCode(this)">复制</button>
                    <pre># 字符串方法示例
text = "Hello, World!"

# 转换为大写
print(text.upper())  # HELLO, WORLD!

# 转换为小写
print(text.lower())  # hello, world!

# 去除首尾空格
text_with_spaces = "  Hello, World!  "
print(text_with_spaces.strip())  # Hello, World!

# 查找子字符串
print(text.find("World"))  # 7

# 替换子字符串
print(text.replace("World", "Python"))  # Hello, Python!

# 分割字符串
csv_data = "apple,banana,orange"
fruits = csv_data.split(",")
print(fruits)  # ['apple', 'banana', 'orange']</pre>
                </div>

                <div class="quiz">
                    <h3>小测验</h3>
                    <div class="quiz-question">以下哪个方法可以将字符串转换为大写？</div>
                    <div class="quiz-options">
                        <label class="quiz-option">
                            <input type="radio" name="q3" value="a">
                            a. toUpperCase()
                        </label>
                        <label class="quiz-option">
                            <input type="radio" name="q3" value="b">
                            b. upper()
                        </label>
                        <label class="quiz-option">
                            <input type="radio" name="q3" value="c">
                            c. to_upper()
                        </label>
                        <label class="quiz-option">
                            <input type="radio" name="q3" value="d">
                            d. uppercase()
                        </label>
                    </div>
                    <button class="btn" onclick="checkAnswer('q3', 'b')">检查答案</button>
                    <div class="quiz-feedback" id="q3-feedback"></div>
                </div>
            </div>
        </section>

        <section id="control-flow" class="section">
            <h2>控制流</h2>
            
            <div id="conditionals">
                <h3>条件语句</h3>
                <p>条件语句允许程序根据不同的条件执行不同的代码块。Python中的条件语句使用if、elif和else关键字。</p>
                
                <h4>if语句</h4>
                <p>最基本的条件语句是if语句，它只在条件为True时执行代码块：</p>
                
                <div class="code-block">
                    <button class="copy-btn" onclick="copyCode(this)">复制</button>
                    <pre># if语句示例
age = 18

if age >= 18:
    print("你已经成年了！")</pre>
                </div>
                
                <h4>if-else语句</h4>
                <p>if-else语句在条件为True时执行一个代码块，在条件为False时执行另一个代码块：</p>
                
                <div class="code-block">
                    <button class="copy-btn" onclick="copyCode(this)">复制</button>
                    <pre># if-else语句示例
age = 16

if age >= 18:
    print("你已经成年了！")
else:
    print("你还未成年。")</pre>
                </div>
                
                <h4>if-elif-else语句</h4>
                <p>当需要检查多个条件时，可以使用if-elif-else语句：</p>
                
                <div class="code-block">
                    <button class="copy-btn" onclick="copyCode(this)">复制</button>
                    <pre># if-elif-else语句示例
score = 85

if score >= 90:
    print("优秀")
elif score >= 80:
    print("良好")
elif score >= 60:
    print("及格")
else:
    print("不及格")</pre>
                </div>
                
                <h4>嵌套条件语句</h4>
                <p>可以在一个条件语句中嵌套另一个条件语句：</p>
                
                <div class="code-block">
                    <button class="copy-btn" onclick="copyCode(this)">复制</button>
                    <pre># 嵌套条件语句示例
age = 20
has_id = True

if age >= 18:
    if has_id:
        print("你可以进入酒吧。")
    else:
        print("你需要身份证才能进入酒吧。")
else:
    print("你还未成年，不能进入酒吧。")</pre>
                </div>

                <div class="note">
                    <p><strong>注意：</strong>在Python中，代码块是通过缩进来定义的，而不是使用大括号{}。通常使用4个空格作为缩进。</p>
                </div>
            </div>
            
            <div id="loops">
                <h3>循环语句</h3>
                <p>循环语句允许程序重复执行一段代码。Python提供了两种主要的循环语句：for循环和while循环。</p>
                
                <h4>for循环</h4>
                <p>for循环用于遍历序列（如列表、元组、字符串等）或其他可迭代对象：</p>
                
                <div class="code-block">
                    <button class="copy-btn" onclick="copyCode(this)">复制</button>
                    <pre># for循环示例
# 遍历列表
fruits = ["apple", "banana", "orange"]
for fruit in fruits:
    print(fruit)

# 遍历字符串
for char in "Python":
    print(char)

# 使用range()函数
for i in range(5):  # 0, 1, 2, 3, 4
    print(i)

# 指定范围的range()
for i in range(2, 6):  # 2, 3, 4, 5
    print(i)

# 指定步长的range()
for i in range(0, 10, 2):  # 0, 2, 4, 6, 8
    print(i)</pre>
                </div>
                
                <h4>while循环</h4>
                <p>while循环在条件为True时重复执行代码块：</p>
                
                <div class="code-block">
                    <button class="copy-btn" onclick="copyCode(this)">复制</button>
                    <pre># while循环示例
count = 0
while count < 5:
    print(count)
    count += 1  # 等同于 count = count + 1</pre>
                </div>
                
                <h4>循环控制语句</h4>
                <p>Python提供了几个循环控制语句，用于改变循环的正常执行流程：</p>
                <ul>
                    <li><strong>break</strong>：立即退出循环</li>
                    <li><strong>continue</strong>：跳过当前迭代，继续下一次迭代</li>
                    <li><strong>pass</strong>：空操作，用于保持程序结构的完整性</li>
                </ul>
                
                <div class="code-block">
                    <button class="copy-btn" onclick="copyCode(this)">复制</button>
                    <pre># 循环控制语句示例
# break示例
for i in range(10):
    if i == 5:
        break
    print(i)  # 输出: 0, 1, 2, 3, 4

# continue示例
for i in range(10):
    if i % 2 == 0:
        continue
    print(i)  # 输出: 1, 3, 5, 7, 9

# pass示例
for i in range(5):
    if i == 2:
        pass  # 什么都不做
    print(i)  # 输出: 0, 1, 2, 3, 4</pre>
                </div>
                
                <h4>嵌套循环</h4>
                <p>可以在一个循环中嵌套另一个循环：</p>
                
                <div class="code-block">
                    <button class="copy-btn" onclick="copyCode(this)">复制</button>
                    <pre># 嵌套循环示例
# 打印乘法表
for i in range(1, 10):
    for j in range(1, i + 1):
        print(f"{j} × {i} = {i * j}", end="\t")
    print()  # 换行</pre>
                </div>

                <div class="quiz">
                    <h3>小测验</h3>
                    <div class="quiz-question">以下哪个语句可以立即退出循环？</div>
                    <div class="quiz-options">
                        <label class="quiz-option">
                            <input type="radio" name="q4" value="a">
                            a. continue
                        </label>
                        <label class="quiz-option">
                            <input type="radio" name="q4" value="b">
                            b. break
                        </label>
                        <label class="quiz-option">
                            <input type="radio" name="q4" value="c">
                            c. pass
                        </label>
                        <label class="quiz-option">
                            <input type="radio" name="q4" value="d">
                            d. exit
                        </label>
                    </div>
                    <button class="btn" onclick="checkAnswer('q4', 'b')">检查答案</button>
                    <div class="quiz-feedback" id="q4-feedback"></div>
                </div>
            </div>
        </section>

        <section id="data-structures" class="section">
            <h2>数据结构</h2>
            
            <div id="lists">
                <h3>列表</h3>
                <p>列表是Python中最常用的数据结构之一，它是一个有序、可变的集合，可以包含任意类型的元素。</p>
                
                <h4>创建列表</h4>
                <div class="code-block">
                    <button class="copy-btn" onclick="copyCode(this)">复制</button>
                    <pre># 创建列表
fruits = ["apple", "banana", "orange"]
numbers = [1, 2, 3, 4, 5]
mixed = [1, "hello", 3.14, True]

# 创建空列表
empty_list = []
empty_list = list()</pre>
                </div>
                
                <h4>访问列表元素</h4>
                <p>列表中的元素可以通过索引访问，索引从0开始：</p>
                
                <div class="code-block">
                    <button class="copy-btn" onclick="copyCode(this)">复制</button>
                    <pre># 访问列表元素
fruits = ["apple", "banana", "orange"]

# 访问第一个元素
print(fruits[0])  # apple

# 访问最后一个元素
print(fruits[-1])  # orange

# 访问第二个元素
print(fruits[1])  # banana</pre>
                </div>
                
                <h4>修改列表</h4>
                <div class="code-block">
                    <button class="copy-btn" onclick="copyCode(this)">复制</button>
                    <pre># 修改列表
fruits = ["apple", "banana", "orange"]

# 修改元素
fruits[1] = "grape"
print(fruits)  # ['apple', 'grape', 'orange']

# 添加元素到末尾
fruits.append("pear")
print(fruits)  # ['apple', 'grape', 'orange', 'pear']

# 在指定位置插入元素
fruits.insert(1, "banana")
print(fruits)  # ['apple', 'banana', 'grape', 'orange', 'pear']

# 删除指定位置的元素
fruits.pop(2)
print(fruits)  # ['apple', 'banana', 'orange', 'pear']

# 删除指定值的元素
fruits.remove("pear")
print(fruits)  # ['apple', 'banana', 'orange']</pre>
                </div>
                
                <h4>列表切片</h4>
                <p>可以使用切片操作获取列表的子集：</p>
                
                <div class="code-block">
                    <button class="copy-btn" onclick="copyCode(this)">复制</button>
                    <pre># 列表切片
numbers = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

# 获取前三个元素
print(numbers[0:3])  # [0, 1, 2]

# 获取从索引2到5的元素
print(numbers[2:6])  # [2, 3, 4, 5]

# 获取从索引3到末尾的元素
print(numbers[3:])  # [3, 4, 5, 6, 7, 8, 9]

# 获取从开始到索引5的元素
print(numbers[:6])  # [0, 1, 2, 3, 4, 5]

# 获取所有元素
print(numbers[:])  # [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

# 使用步长
print(numbers[::2])  # [0, 2, 4, 6, 8]</pre>
                </div>
                
                <h4>列表排序</h4>
                <div class="code-block">
                    <button class="copy-btn" onclick="copyCode(this)">复制</button>
                    <pre># 列表排序
numbers = [3, 1, 4, 1, 5, 9, 2, 6]

# 升序排序（修改原列表）
numbers.sort()
print(numbers)  # [1, 1, 2, 3, 4, 5, 6, 9]

# 降序排序（修改原列表）
numbers.sort(reverse=True)
print(numbers)  # [9, 6, 5, 4, 3, 2, 1, 1]

# 返回排序后的新列表（不修改原列表）
numbers = [3, 1, 4, 1, 5, 9, 2, 6]
sorted_numbers = sorted(numbers)
print(numbers)  # [3, 1, 4, 1, 5, 9, 2, 6]
print(sorted_numbers)  # [1, 1, 2, 3, 4, 5, 6, 9]</pre>
                </div>
            </div>
            
            <div id="tuples">
                <h3>元组</h3>
                <p>元组与列表类似，但是元组是不可变的，一旦创建就不能修改。元组使用圆括号()表示。</p>
                
                <h4>创建元组</h4>
                <div class="code-block">
                    <button class="copy-btn" onclick="copyCode(this)">复制</button>
                    <pre># 创建元组
fruits = ("apple", "banana", "orange")
numbers = (1, 2, 3, 4, 5)
mixed = (1, "hello", 3.14, True)

# 创建单元素元组（需要加逗号）
single_element = (1,)

# 创建空元组
empty_tuple = ()
empty_tuple = tuple()</pre>
                </div>
                
                <h4>访问元组元素</h4>
                <p>元组元素的访问方式与列表相同：</p>
                
                <div class="code-block">
                    <button class="copy-btn" onclick="copyCode(this)">复制</button>
                    <pre># 访问元组元素
fruits = ("apple", "banana", "orange")

# 访问第一个元素
print(fruits[0])  # apple

# 访问最后一个元素
print(fruits[-1])  # orange

# 元组切片
print(fruits[1:3])  # ('banana', 'orange')</pre>
                </div>
                
                <h4>元组与列表的区别</h4>
                <ul>
                    <li>元组是不可变的，而列表是可变的</li>
                    <li>元组使用圆括号()，而列表使用方括号[]</li>
                    <li>元组通常用于存储不应修改的数据</li>
                    <li>元组比列表更节省内存</li>
                </ul>
                
                <div class="code-block">
                    <button class="copy-btn" onclick="copyCode(this)">复制</button>
                    <pre># 元组与列表的区别
# 列表是可变的
fruits_list = ["apple", "banana", "orange"]
fruits_list[1] = "grape"  # 可以修改
print(fruits_list)  # ['apple', 'grape', 'orange']

# 元组是不可变的
fruits_tuple = ("apple", "banana", "orange")
# fruits_tuple[1] = "grape"  # 这会引发TypeError</pre>
                </div>
            </div>
            
            <div id="dictionaries">
                <h3>字典</h3>
                <p>字典是Python中的一种键值对集合，每个键都与一个值相关联。字典使用花括号{}表示，键和值之间用冒号:分隔。</p>
                
                <h4>创建字典</h4>
                <div class="code-block">
                    <button class="copy-btn" onclick="copyCode(this)">复制</button>
                    <pre># 创建字典
student = {
    "name": "张三",
    "age": 20,
    "major": "计算机科学",
    "grades": [85, 90, 78, 92]
}

# 创建空字典
empty_dict = {}
empty_dict = dict()</pre>
                </div>
                
                <h4>访问字典元素</h4>
                <div class="code-block">
                    <button class="copy-btn" onclick="copyCode(this)">复制</button>
                    <pre># 访问字典元素
student = {
    "name": "张三",
    "age": 20,
    "major": "计算机科学"
}

# 使用键访问值
print(student["name"])  # 张三
print(student["age"])   # 20

# 使用get()方法访问值（如果键不存在，返回None或默认值）
print(student.get("name"))  # 张三
print(student.get("grade"))  # None
print(student.get("grade", "N/A"))  # N/A</pre>
                </div>
                
                <h4>修改字典</h4>
                <div class="code-block">
                    <button class="copy-btn" onclick="copyCode(this)">复制</button>
                    <pre># 修改字典
student = {
    "name": "张三",
    "age": 20,
    "major": "计算机科学"
}

# 修改值
student["age"] = 21
print(student)  # {'name': '张三', 'age': 21, 'major': '计算机科学'}

# 添加键值对
student["grade"] = "A"
print(student)  # {'name': '张三', 'age': 21, 'major': '计算机科学', 'grade': 'A'}

# 删除键值对
del student["grade"]
print(student)  # {'name': '张三', 'age': 21, 'major': '计算机科学'}

# 使用pop()方法删除键值对并返回值
major = student.pop("major")
print(major)    # 计算机科学
print(student)  # {'name': '张三', 'age': 21}</pre>
                </div>
                
                <h4>遍历字典</h4>
                <div class="code-block">
                    <button class="copy-btn" onclick="copyCode(this)">复制</button>
                    <pre># 遍历字典
student = {
    "name": "张三",
    "age": 21,
    "major": "计算机科学"
}

# 遍历键
for key in student:
    print(key)

# 遍历值
for value in student.values():
    print(value)

# 遍历键值对
for key, value in student.items():
    print(f"{key}: {value}")</pre>
                </div>
            </div>
            
            <div id="sets">
                <h3>集合</h3>
                <p>集合是一个无序、不重复的元素集合。集合使用花括号{}表示，或者使用set()函数创建。</p>
                
                <h4>创建集合</h4>
                <div class="code-block">
                    <button class="copy-btn" onclick="copyCode(this)">复制</button>
                    <pre># 创建集合
fruits = {"apple", "banana", "orange"}
numbers = {1, 2, 3, 4, 5}

# 从列表创建集合（会自动去除重复元素）
numbers_list = [1, 2, 2, 3, 4, 4, 5]
unique_numbers = set(numbers_list)
print(unique_numbers)  # {1, 2, 3, 4, 5}

# 创建空集合（必须使用set()，因为{}创建的是空字典）
empty_set = set()</pre>
                </div>
                
                <h4>修改集合</h4>
                <div class="code-block">
                    <button class="copy-btn" onclick="copyCode(this)">复制</button>
                    <pre># 修改集合
fruits = {"apple", "banana", "orange"}

# 添加元素
fruits.add("pear")
print(fruits)  # {'orange', 'pear', 'banana', 'apple'}

# 添加多个元素
fruits.update(["grape", "mango"])
print(fruits)  # {'orange', 'pear', 'mango', 'banana', 'apple', 'grape'}

# 删除元素
fruits.remove("banana")
print(fruits)  # {'orange', 'pear', 'mango', 'apple', 'grape'}

# 如果元素不存在，remove()会引发错误，而discard()不会
fruits.discard("banana")  # 不会引发错误
# fruits.remove("banana")  # 会引发KeyError</pre>
                </div>
                
                <h4>集合操作</h4>
                <div class="code-block">
                    <button class="copy-btn" onclick="copyCode(this)">复制</button>
                    <pre># 集合操作
set1 = {1, 2, 3, 4, 5}
set2 = {4, 5, 6, 7, 8}

# 并集（包含两个集合中的所有元素）
union_set = set1 | set2
print(union_set)  # {1, 2, 3, 4, 5, 6, 7, 8}

# 交集（包含两个集合中都存在的元素）
intersection_set = set1 & set2
print(intersection_set)  # {4, 5}

# 差集（包含在第一个集合中但不在第二个集合中的元素）
difference_set = set1 - set2
print(difference_set)  # {1, 2, 3}

# 对称差集（包含在任一集合中但不同时存在于两个集合中的元素）
symmetric_difference_set = set1 ^ set2
print(symmetric_difference_set)  # {1, 2, 3, 6, 7, 8}</pre>
                </div>

                <div class="quiz">
                    <h3>小测验</h3>
                    <div class="quiz-question">以下哪种数据结构是无序且不重复的？</div>
                    <div class="quiz-options">
                        <label class="quiz-option">
                            <input type="radio" name="q5" value="a">
                            a. 列表
                        </label>
                        <label class="quiz-option">
                            <input type="radio" name="q5" value="b">
                            b. 元组
                        </label>
                        <label class="quiz-option">
                            <input type="radio" name="q5" value="c">
                            c. 字典
                        </label>
                        <label class="quiz-option">
                            <input type="radio" name="q5" value="d">
                            d. 集合
                        </label>
                    </div>
                    <button class="btn" onclick="checkAnswer('q5', 'd')">检查答案</button>
                    <div class="quiz-feedback" id="q5-feedback"></div>
                </div>
            </div>
        </section>

        <section id="functions" class="section">
            <h2>函数</h2>
            <p>函数是一段可重复使用的代码，用于执行特定的任务。在Python中，使用def关键字定义函数。</p>
            
            <h3>定义和调用函数</h3>
            <div class="code-block">
                <button class="copy-btn" onclick="copyCode(this)">复制</button>
                <pre># 定义函数
def greet():
    print("Hello, World!")

# 调用函数
greet()  # 输出: Hello, World!</pre>
            </div>
            
            <h3>带参数的函数</h3>
            <div class="code-block">
                <button class="copy-btn" onclick="copyCode(this)">复制</button>
                <pre># 带参数的函数
def greet(name):
    print(f"Hello, {name}!")

# 调用函数
greet("Alice")  # 输出: Hello, Alice!
greet("Bob")    # 输出: Hello, Bob!</pre>
            </div>
            
            <h3>带默认值的参数</h3>
            <div class="code-block">
                <button class="copy-btn" onclick="copyCode(this)">复制</button>
                <pre># 带默认值的参数
def greet(name="World"):
    print(f"Hello, {name}!")

# 调用函数
greet()        # 输出: Hello, World!
greet("Alice") # 输出: Hello, Alice!</pre>
            </div>
            
            <h3>返回值</h3>
            <div class="code-block">
                <button class="copy-btn" onclick="copyCode(this)">复制</button>
                <pre># 带返回值的函数
def add(a, b):
    return a + b

# 调用函数并使用返回值
result = add(3, 5)
print(result)  # 输出: 8

# 直接在表达式中使用返回值
print(add(10, 20))  # 输出: 30</pre>
            </div>
            
            <h3>多返回值</h3>
            <div class="code-block">
                <button class="copy-btn" onclick="copyCode(this)">复制</button>
                <pre># 返回多个值
def calculate(a, b):
    sum = a + b
    difference = a - b
    product = a * b
    return sum, difference, product

# 调用函数并接收多个返回值
s, d, p = calculate(10, 5)
print(f"和: {s}, 差: {d}, 积: {p}")  # 输出: 和: 15, 差: 5, 积: 50

# 也可以将返回值作为一个元组接收
result = calculate(10, 5)
print(result)  # 输出: (15, 5, 50)</pre>
            </div>
            
            <h3>关键字参数</h3>
            <div class="code-block">
                <button class="copy-btn" onclick="copyCode(this)">复制</button>
                <pre># 关键字参数
def describe_person(name, age, gender):
    print(f"姓名: {name}, 年龄: {age}, 性别: {gender}")

# 使用位置参数
describe_person("张三", 25, "男")

# 使用关键字参数（可以不按顺序）
describe_person(age=25, name="张三", gender="男")

# 混合使用位置参数和关键字参数
describe_person("张三", age=25, gender="男")</pre>
            </div>
            
            <h3>可变参数</h3>
            <div class="code-block">
                <button class="copy-btn" onclick="copyCode(this)">复制</button>
                <pre># 可变位置参数 (*args)
def sum_all(*numbers):
    total = 0
    for num in numbers:
        total += num
    return total

# 调用函数
print(sum_all(1, 2, 3))        # 输出: 6
print(sum_all(10, 20, 30, 40)) # 输出: 100

# 可变关键字参数 (**kwargs)
def print_info(**info):
    for key, value in info.items():
        print(f"{key}: {value}")

# 调用函数
print_info(name="张三", age=25, city="北京")
# 输出:
# name: 张三
# age: 25
# city: 北京</pre>
            </div>
            
            <h3>匿名函数（lambda）</h3>
            <div class="code-block">
                <button class="copy-btn" onclick="copyCode(this)">复制</button>
                <pre># lambda函数
multiply = lambda x, y: x * y

# 调用lambda函数
print(multiply(3, 4))  # 输出: 12

# 常用于高阶函数
numbers = [1, 2, 3, 4, 5]
squared_numbers = list(map(lambda x: x ** 2, numbers))
print(squared_numbers)  # 输出: [1, 4, 9, 16, 25]

even_numbers = list(filter(lambda x: x % 2 == 0, numbers))
print(even_numbers)  # 输出: [2, 4]</pre>
            </div>

            <div class="quiz">
                <h3>小测验</h3>
                <div class="quiz-question">以下哪个关键字用于定义函数？</div>
                <div class="quiz-options">
                    <label class="quiz-option">
                        <input type="radio" name="q6" value="a">
                        a. function
                    </label>
                    <label class="quiz-option">
                        <input type="radio" name="q6" value="b">
                        b. def
                    </label>
                    <label class="quiz-option">
                        <input type="radio" name="q6" value="c">
                        c. func
                    </label>
                    <label class="quiz-option">
                        <input type="radio" name="q6" value="d">
                        d. define
                    </label>
                </div>
                <button class="btn" onclick="checkAnswer('q6', 'b')">检查答案</button>
                <div class="quiz-feedback" id="q6-feedback"></div>
            </div>
        </section>

        <section id="modules" class="section">
            <h2>模块与包</h2>
            <p>模块是包含Python定义和语句的文件，包是包含多个模块的目录。模块和包是Python代码组织和重用的重要方式。</p>
            
            <h3>导入模块</h3>
            <div class="code-block">
                <button class="copy-btn" onclick="copyCode(this)">复制</button>
                <pre># 导入整个模块
import math
print(math.sqrt(16))  # 输出: 4.0

# 导入模块中的特定函数
from math import sqrt
print(sqrt(16))  # 输出: 4.0

# 导入模块中的所有函数（不推荐）
from math import *
print(sqrt(16))  # 输出: 4.0

# 给模块起别名
import math as m
print(m.sqrt(16))  # 输出: 4.0</pre>
            </div>
            
            <h3>常用标准模块</h3>
            <div class="code-block">
                <button class="copy-btn" onclick="copyCode(this)">复制</button>
                <pre># math模块 - 数学函数
import math
print(math.pi)       # 输出: 3.141592653589793
print(math.sin(0))   # 输出: 0.0
print(math.cos(0))   # 输出: 1.0

# random模块 - 随机数生成
import random
print(random.randint(1, 10))  # 输出1到10之间的随机整数
print(random.choice(["apple", "banana", "orange"]))  # 随机选择一个元素

# datetime模块 - 日期和时间处理
import datetime
now = datetime.datetime.now()
print(now)  # 输出当前日期和时间
print(now.strftime("%Y-%m-%d %H:%M:%S"))  # 格式化输出

# os模块 - 操作系统接口
import os
print(os.getcwd())  # 输出当前工作目录
print(os.listdir("."))  # 列出当前目录的文件和文件夹</pre>
            </div>
            
            <h3>创建自定义模块</h3>
            <p>创建一个名为mymodule.py的文件：</p>
            <div class="code-block">
                <button class="copy-btn" onclick="copyCode(this)">复制</button>
                <pre># mymodule.py
def greet(name):
    return f"Hello, {name}!"

def add(a, b):
    return a + b

PI = 3.14159</pre>
            </div>
            <p>然后在另一个文件中使用这个模块：</p>
            <div class="code-block">
                <button class="copy-btn" onclick="copyCode(this)">复制</button>
                <pre># main.py
import mymodule

print(mymodule.greet("Alice"))  # 输出: Hello, Alice!
print(mymodule.add(3, 5))       # 输出: 8
print(mymodule.PI)              # 输出: 3.14159</pre>
            </div>
            
            <h3>创建包</h3>
            <p>包是一个包含__init__.py文件的目录，__init__.py文件可以为空，也可以包含包的初始化代码。</p>
            <p>创建以下目录结构：</p>
            <pre>
            mypackage/
            ├── __init__.py
            ├── module1.py
            └── module2.py
            </pre>
            <p>在module1.py中：</p>
            <div class="code-block">
                <button class="copy-btn" onclick="copyCode(this)">复制</button>
                <pre># module1.py
def function1():
    return "This is function1 from module1"</pre>
            </div>
            <p>在module2.py中：</p>
            <div class="code-block">
                <button class="copy-btn" onclick="copyCode(this)">复制</button>
                <pre># module2.py
def function2():
    return "This is function2 from module2"</pre>
            </div>
            <p>然后在另一个文件中使用这个包：</p>
            <div class="code-block">
                <button class="copy-btn" onclick="copyCode(this)">复制</button>
                <pre># main.py
from mypackage import module1, module2

print(module1.function1())  # 输出: This is function1 from module1
print(module2.function2())  # 输出: This is function2 from module2</pre>
            </div>
            
            <h3>安装第三方包</h3>
            <p>使用pip工具可以安装第三方包：</p>
            <div class="code-block">
                <button class="copy-btn" onclick="copyCode(this)">复制</button>
                <pre># 安装包
pip install numpy

# 升级包
pip install --upgrade numpy

# 卸载包
pip uninstall numpy

# 查看已安装的包
pip list</pre>
            </div>
            
            <h3>使用第三方包</h3>
            <div class="code-block">
                <button class="copy-btn" onclick="copyCode(this)">复制</button>
                <pre># 使用numpy包
import numpy as np

# 创建数组
a = np.array([1, 2, 3, 4, 5])
print(a)

# 数组运算
b = np.array([6, 7, 8, 9, 10])
print(a + b)  # [ 7  9 11 13 15]

# 使用requests包
import requests

# 发送HTTP请求
response = requests.get("https://www.example.com")
print(response.status_code)  # 200
print(response.text[:100])   # 输出网页内容的前100个字符</pre>
            </div>
        </section>

        <section id="file-io" class="section">
            <h2>文件操作</h2>
            <p>文件操作是编程中常见的任务，Python提供了简单而强大的文件操作功能。</p>
            
            <h3>打开和关闭文件</h3>
            <div class="code-block">
                <button class="copy-btn" onclick="copyCode(this)">复制</button>
                <pre># 打开文件
f = open("example.txt", "r")  # "r"表示读取模式

# 关闭文件
f.close()

# 使用with语句自动关闭文件（推荐）
with open("example.txt", "r") as f:
    content = f.read()
    # 文件会在with块结束时自动关闭</pre>
            </div>
            
            <h3>文件打开模式</h3>
            <ul>
                <li><strong>"r"</strong>：读取模式（默认）</li>
                <li><strong>"w"</strong>：写入模式（会覆盖已有文件）</li>
                <li><strong>"a"</strong>：追加模式（在文件末尾添加内容）</li>
                <li><strong>"x"</strong>：独占创建模式（如果文件已存在会引发错误）</li>
                <li><strong>"b"</strong>：二进制模式（与其他模式结合使用，如"rb"、"wb"）</li>
                <li><strong>"+"</strong>：读写模式（与其他模式结合使用，如"r+"、"w+"）</li>
            </ul>
            
            <h3>读取文件</h3>
            <div class="code-block">
                <button class="copy-btn" onclick="copyCode(this)">复制</button>
                <pre># 读取整个文件
with open("example.txt", "r") as f:
    content = f.read()
    print(content)

# 逐行读取
with open("example.txt", "r") as f:
    for line in f:
        print(line.strip())  # strip()去除行尾的换行符

# 读取指定数量的字符
with open("example.txt", "r") as f:
    content = f.read(10)  # 读取前10个字符
    print(content)

# 读取所有行到一个列表
with open("example.txt", "r") as f:
    lines = f.readlines()
    print(lines)</pre>
            </div>
            
            <h3>写入文件</h3>
            <div class="code-block">
                <button class="copy-btn" onclick="copyCode(this)">复制</button>
                <pre># 写入字符串
with open("output.txt", "w") as f:
    f.write("Hello, World!\n")
    f.write("This is a test.\n")

# 写入多行
lines = ["Line 1\n", "Line 2\n", "Line 3\n"]
with open("output.txt", "w") as f:
    f.writelines(lines)

# 追加内容
with open("output.txt", "a") as f:
    f.write("This line is appended.\n")</pre>
            </div>
            
            <h3>文件和目录操作</h3>
            <div class="code-block">
                <button class="copy-btn" onclick="copyCode(this)">复制</button>
                <pre>import os

# 检查文件是否存在
if os.path.exists("example.txt"):
    print("文件存在")
else:
    print("文件不存在")

# 检查是否是文件
if os.path.isfile("example.txt"):
    print("这是一个文件")

# 检查是否是目录
if os.path.isdir("my_folder"):
    print("这是一个目录")

# 创建目录
os.mkdir("new_folder")  # 创建单级目录
os.makedirs("parent/child")  # 创建多级目录

# 删除文件
os.remove("example.txt")

# 删除目录
os.rmdir("empty_folder")  # 只能删除空目录
os.removedirs("parent/child")  # 删除多级空目录

# 重命名文件或目录
os.rename("old_name.txt", "new_name.txt")

# 获取当前工作目录
current_dir = os.getcwd()
print(current_dir)

# 改变当前工作目录
os.chdir("/path/to/directory")

# 获取文件大小
file_size = os.path.getsize("example.txt")
print(f"文件大小: {file_size} 字节")</pre>
            </div>
            
            <h3>使用pathlib模块</h3>
            <p>pathlib模块提供了面向对象的文件系统路径操作方式：</p>
            <div class="code-block">
                <button class="copy-btn" onclick="copyCode(this)">复制</button>
                <pre>from pathlib import Path

# 创建Path对象
p = Path("example.txt")

# 检查文件是否存在
if p.exists():
    print("文件存在")

# 获取文件名
print(p.name)  # example.txt

# 获取文件扩展名
print(p.suffix)  # .txt

# 获取文件所在目录
print(p.parent)  # .

# 读取文件内容
content = p.read_text()
print(content)

# 写入文件内容
p.write_text("Hello, World!")

# 创建目录
dir_path = Path("new_folder")
dir_path.mkdir(exist_ok=True)  # exist_ok=True表示目录已存在时不报错

# 遍历目录
for item in Path(".").iterdir():
    if item.is_file():
        print(f"文件: {item.name}")
    elif item.is_dir():
        print(f"目录: {item.name}")</pre>
            </div>

            <div class="quiz">
                <h3>小测验</h3>
                <div class="quiz-question">以下哪种文件打开模式会覆盖已有文件？</div>
                <div class="quiz-options">
                    <label class="quiz-option">
                        <input type="radio" name="q7" value="a">
                        a. "r"
                    </label>
                    <label class="quiz-option">
                        <input type="radio" name="q7" value="b">
                        b. "w"
                    </label>
                    <label class="quiz-option">
                        <input type="radio" name="q7" value="c">
                        c. "a"
                    </label>
                    <label class="quiz-option">
                        <input type="radio" name="q7" value="d">
                        d. "x"
                    </label>
                </div>
                <button class="btn" onclick="checkAnswer('q7', 'b')">检查答案</button>
                <div class="quiz-feedback" id="q7-feedback"></div>
            </div>
        </section>

        <section id="exceptions" class="section">
            <h2>异常处理</h2>
            <p>异常是程序运行时发生的错误。Python提供了异常处理机制，使程序能够在遇到错误时优雅地处理，而不是直接崩溃。</p>
            
            <h3>常见的异常类型</h3>
            <ul>
                <li><strong>NameError</strong>：尝试访问未声明的变量</li>
                <li><strong>TypeError</strong>：操作或函数应用于不适当类型的对象</li>
                <li><strong>ValueError</strong>：操作或函数接收到具有正确类型但不适当值的参数</li>
                <li><strong>IndexError</strong>：序列索引超出范围</li>
                <li><strong>KeyError</strong>：字典中不存在指定的键</li>
                <li><strong>FileNotFoundError</strong>：尝试打开不存在的文件</li>
                <li><strong>ZeroDivisionError</strong>：除以零</li>
            </ul>
            
            <h3>try-except语句</h3>
            <div class="code-block">
                <button class="copy-btn" onclick="copyCode(this)">复制</button>
                <pre># 基本的try-except语句
try:
    result = 10 / 0
except ZeroDivisionError:
    print("除数不能为零")

# 捕获多个异常
try:
    num = int("abc")
except ValueError:
    print("无法将字符串转换为整数")
except TypeError:
    print("类型错误")

# 捕获所有异常
try:
    result = 10 / 0
except Exception as e:
    print(f"发生错误: {e}")</pre>
            </div>
            
            <h3>try-except-else语句</h3>
            <div class="code-block">
                <button class="copy-btn" onclick="copyCode(this)">复制</button>
                <pre># try-except-else语句
try:
    num = int("123")
except ValueError:
    print("无法将字符串转换为整数")
else:
    print(f"转换成功: {num}")</pre>
            </div>
            
            <h3>try-except-finally语句</h3>
            <div class="code-block">
                <button class="copy-btn" onclick="copyCode(this)">复制</button>
                <pre># try-except-finally语句
try:
    f = open("example.txt", "r")
    content = f.read()
except FileNotFoundError:
    print("文件不存在")
finally:
    # 无论是否发生异常，finally块中的代码都会执行
    if 'f' in locals():
        f.close()
    print("文件操作完成")</pre>
            </div>
            
            <h3>抛出异常</h3>
            <div class="code-block">
                <button class="copy-btn" onclick="copyCode(this)">复制</button>
                <pre># 使用raise语句抛出异常
def divide(a, b):
    if b == 0:
        raise ValueError("除数不能为零")
    return a / b

try:
    result = divide(10, 0)
except ValueError as e:
    print(f"错误: {e}")

# 抛出内置异常
age = -5
if age < 0:
    raise ValueError("年龄不能为负数")

# 创建自定义异常
class CustomError(Exception):
    pass

def check_value(value):
    if value < 0:
        raise CustomError("值不能为负数")
    return value

try:
    check_value(-5)
except CustomError as e:
    print(f"自定义错误: {e}")</pre>
            </div>
            
            <h3>异常的层次结构</h3>
            <p>Python中的所有异常都继承自BaseException类，常见的异常类继承自Exception类：</p>
            <div class="code-block">
                <button class="copy-btn" onclick="copyCode(this)">复制</button>
                <pre># 异常的层次结构示例
try:
    # 可能引发多种异常的代码
    num = int("abc")
    result = 10 / num
except ValueError as e:
    print(f"值错误: {e}")
except ZeroDivisionError as e:
    print(f"除零错误: {e}")
except Exception as e:
    print(f"其他错误: {e}")
else:
    print(f"结果: {result}")
finally:
    print("操作完成")</pre>
            </div>
            
            <h3>使用with语句处理资源</h3>
            <p>with语句可以自动管理资源，如文件、网络连接等，即使在处理过程中发生异常也能正确释放资源：</p>
            <div class="code-block">
                <button class="copy-btn" onclick="copyCode(this)">复制</button>
                <pre># 使用with语句处理文件
try:
    with open("example.txt", "r") as f:
        content = f.read()
        # 这里可能会发生异常
        num = int(content)
except ValueError:
    print("文件内容不是有效的整数")
except FileNotFoundError:
    print("文件不存在")
# 文件会自动关闭，无论是否发生异常</pre>
            </div>
        </section>

        <section id="oop" class="section">
            <h2>面向对象编程</h2>
            <p>面向对象编程（OOP）是一种编程范式，它使用"对象"来设计应用程序和计算机程序。Python是一种面向对象的语言，支持面向对象编程的所有特性。</p>
            
            <h3>类和对象</h3>
            <p>类是创建对象的蓝图，对象是类的实例。类定义了对象的属性和方法。</p>
            <div class="code-block">
                <button class="copy-btn" onclick="copyCode(this)">复制</button>
                <pre># 定义一个简单的类
class Person:
    # 类属性
    species = "人类"
    
    # 初始化方法（构造函数）
    def __init__(self, name, age):
        # 实例属性
        self.name = name
        self.age = age
    
    # 实例方法
    def introduce(self):
        return f"我叫{self.name}，今年{self.age}岁。"
    
    # 另一个实例方法
    def celebrate_birthday(self):
        self.age += 1
        return f"生日快乐！我现在{self.age}岁了。"

# 创建对象（实例化）
person1 = Person("张三", 25)
person2 = Person("李四", 30)

# 访问属性
print(person1.name)  # 输出: 张三
print(person2.age)   # 输出: 30

# 访问类属性
print(person1.species)  # 输出: 人类

# 调用方法
print(person1.introduce())  # 输出: 我叫张三，今年25岁。
print(person2.celebrate_birthday())  # 输出: 生日快乐！我现在31岁了。</pre>
            </div>
            
            <h3>继承</h3>
            <p>继承允许我们定义一个类，该类继承另一个类的所有方法和属性。父类是被继承的类，子类是继承父类的类。</p>
            <div class="code-block">
                <button class="copy-btn" onclick="copyCode(this)">复制</button>
                <pre># 定义父类
class Animal:
    def __init__(self, name):
        self.name = name
    
    def speak(self):
        raise NotImplementedError("子类必须实现此方法")
    
    def eat(self):
        return f"{self.name}正在吃东西。"

# 定义子类
class Dog(Animal):
    def __init__(self, name, breed):
        # 调用父类的初始化方法
        super().__init__(name)
        self.breed = breed
    
    # 重写父类的方法
    def speak(self):
        return f"{self.name}说：汪汪！"
    
    # 子类特有的方法
    def fetch(self):
        return f"{self.name}正在取球。"

# 定义另一个子类
class Cat(Animal):
    def __init__(self, name, color):
        super().__init__(name)
        self.color = color
    
    def speak(self):
        return f"{self.name}说：喵喵！"
    
    def climb(self):
        return f"{self.name}正在爬树。"

# 创建子类对象
dog = Dog("旺财", "金毛")
cat = Cat("咪咪", "白色")

# 调用方法
print(dog.speak())  # 输出: 旺财说：汪汪！
print(cat.speak())  # 输出: 咪咪说：喵喵！

# 调用继承的方法
print(dog.eat())    # 输出: 旺财正在吃东西。
print(cat.eat())    # 输出: 咪咪正在吃东西。

# 调用子类特有的方法
print(dog.fetch())  # 输出: 旺财正在取球。
print(cat.climb())  # 输出: 咪咪正在爬树。</pre>
            </div>
            
            <h3>封装</h3>
            <p>封装是指将数据（属性）和操作数据的方法捆绑在一起，形成一个独立的对象。在Python中，可以使用访问修饰符来实现封装。</p>
            <div class="code-block">
                <button class="copy-btn" onclick="copyCode(this)">复制</button>
                <pre># 封装示例
class BankAccount:
    def __init__(self, account_number, balance=0):
        # 公有属性
        self.account_number = account_number
        
        # 受保护的属性（以单下划线开头）
        self._balance = balance
        
        # 私有属性（以双下划线开头）
        self.__transactions = []
    
    # 公有方法
    def deposit(self, amount):
        if amount > 0:
            self._balance += amount
            self.__transactions.append(f"存款: +{amount}")
            return True
        return False
    
    def withdraw(self, amount):
        if 0 < amount <= self._balance:
            self._balance -= amount
            self.__transactions.append(f"取款: -{amount}")
            return True
        return False
    
    def get_balance(self):
        return self._balance
    
    def get_transactions(self):
        return self.__transactions

# 创建对象
account = BankAccount("1234567890")

# 访问公有属性和方法
print(account.account_number)  # 输出: 1234567890
account.deposit(1000)
account.withdraw(500)

# 访问受保护的属性（不推荐，但可以访问）
print(account._balance)  # 输出: 500

# 尝试访问私有属性（会引发错误）
# print(account.__transactions)  # AttributeError: 'BankAccount' object has no attribute '__transactions'

# 通过方法访问私有属性
print(account.get_transactions())  # 输出: ['存款: +1000', '取款: -500']</pre>
            </div>
            
            <h3>多态</h3>
            <p>多态是指不同类的对象对同一消息（方法调用）可以做出不同的响应。在Python中，多态是通过继承和方法重写实现的。</p>
            <div class="code-block">
                <button class="copy-btn" onclick="copyCode(this)">复制</button>
                <pre># 多态示例
class Shape:
    def area(self):
        raise NotImplementedError("子类必须实现此方法")
    
    def perimeter(self):
        raise NotImplementedError("子类必须实现此方法")

class Rectangle(Shape):
    def __init__(self, width, height):
        self.width = width
        self.height = height
    
    def area(self):
        return self.width * self.height
    
    def perimeter(self):
        return 2 * (self.width + self.height)

class Circle(Shape):
    def __init__(self, radius):
        self.radius = radius
    
    def area(self):
        return 3.14 * self.radius ** 2
    
    def perimeter(self):
        return 2 * 3.14 * self.radius

class Triangle(Shape):
    def __init__(self, base, height, side1, side2, side3):
        self.base = base
        self.height = height
        self.side1 = side1
        self.side2 = side2
        self.side3 = side3
    
    def area(self):
        return 0.5 * self.base * self.height
    
    def perimeter(self):
        return self.side1 + self.side2 + self.side3

# 创建不同形状的对象
rectangle = Rectangle(5, 4)
circle = Circle(3)
triangle = Triangle(4, 3, 3, 4, 5)

# 使用多态
shapes = [rectangle, circle, triangle]

for shape in shapes:
    print(f"形状: {shape.__class__.__name__}")
    print(f"面积: {shape.area()}")
    print(f"周长: {shape.perimeter()}")
    print()</pre>
            </div>
            
            <h3>特殊方法（魔术方法）</h3>
            <p>Python类中有很多以双下划线开头和结尾的特殊方法，它们用于实现类的特定行为。</p>
            <div class="code-block">
                <button class="copy-btn" onclick="copyCode(this)">复制</button>
                <pre># 特殊方法示例
class Vector:
    def __init__(self, x, y):
        self.x = x
        self.y = y
    
    # 字符串表示
    def __str__(self):
        return f"Vector({self.x}, {self.y})"
    
    # 官方字符串表示
    def __repr__(self):
        return f"Vector({self.x}, {self.y})"
    
    # 加法运算
    def __add__(self, other):
        return Vector(self.x + other.x, self.y + other.y)
    
    # 减法运算
    def __sub__(self, other):
        return Vector(self.x - other.x, self.y - other.y)
    
    # 乘法运算（与标量）
    def __mul__(self, scalar):
        return Vector(self.x * scalar, self.y * scalar)
    
    # 等于比较
    def __eq__(self, other):
        return self.x == other.x and self.y == other.y
    
    # 小于比较
    def __lt__(self, other):
        return self.x ** 2 + self.y ** 2 < other.x ** 2 + other.y ** 2

# 创建对象
v1 = Vector(3, 4)
v2 = Vector(1, 2)

# 使用特殊方法
print(v1)  # 调用__str__，输出: Vector(3, 4)
print(repr(v1))  # 调用__repr__，输出: Vector(3, 4)

v3 = v1 + v2  # 调用__add__
print(v3)  # 输出: Vector(4, 6)

v4 = v1 - v2  # 调用__sub__
print(v4)  # 输出: Vector(2, 2)

v5 = v1 * 2  # 调用__mul__
print(v5)  # 输出: Vector(6, 8)

print(v1 == v2)  # 调用__eq__，输出: False
print(v1 < v2)  # 调用__lt__，输出: False</pre>
            </div>
            
            <h3>静态方法和类方法</h3>
            <div class="code-block">
                <button class="copy-btn" onclick="copyCode(this)">复制</button>
                <pre># 静态方法和类方法示例
class MathUtils:
    # 类属性
    PI = 3.14159
    
    # 静态方法（不需要self或cls参数）
    @staticmethod
    def add(a, b):
        return a + b
    
    @staticmethod
    def multiply(a, b):
        return a * b
    
    # 类方法（需要cls参数）
    @classmethod
    def circle_area(cls, radius):
        return cls.PI * radius ** 2
    
    @classmethod
    def circle_circumference(cls, radius):
        return 2 * cls.PI * radius

# 调用静态方法
print(MathUtils.add(5, 3))  # 输出: 8
print(MathUtils.multiply(4, 6))  # 输出: 24

# 调用类方法
print(MathUtils.circle_area(5))  # 输出: 78.53975
print(MathUtils.circle_circumference(5))  # 输出: 31.4159</pre>
            </div>

            <div class="quiz">
                <h3>小测验</h3>
                <div class="quiz-question">在Python中，以下哪个关键字用于调用父类的方法？</div>
                <div class="quiz-options">
                    <label class="quiz-option">
                        <input type="radio" name="q8" value="a">
                        a. parent
                    </label>
                    <label class="quiz-option">
                        <input type="radio" name="q8" value="b">
                        b. super
                    </label>
                    <label class="quiz-option">
                        <input type="radio" name="q8" value="c">
                        c. base
                    </label>
                    <label class="quiz-option">
                        <input type="radio" name="q8" value="d">
                        d. this
                    </label>
                </div>
                <button class="btn" onclick="checkAnswer('q8', 'b')">检查答案</button>
                <div class="quiz-feedback" id="q8-feedback"></div>
            </div>
        </section>
    </div>

    <footer>
        <div class="container">
            <div class="footer-content">
                <div>
                    <p>&copy; 2025 Python入门教程.levi_jia 珠海科技学院 电子设计协会</p>
                </div>
                
            </div>
        </div>
    </footer>

    <script>
        // 侧边栏折叠功能
        document.addEventListener('DOMContentLoaded', function() {
            const sidebar = document.getElementById('sidebar');
            const sidebarToggle = document.getElementById('sidebarToggle');
            const content = document.getElementById('content');
            const menuToggle = document.getElementById('menuToggle');
            const navOverlay = document.getElementById('navOverlay');
            
            // 侧边栏折叠/展开
            sidebarToggle.addEventListener('click', function() {
                sidebar.classList.toggle('collapsed');
                content.classList.toggle('expanded');
                const hero = document.querySelector('.hero');
                hero.classList.toggle('expanded');
                
                // 更新按钮图标
                const icon = sidebarToggle.querySelector('i');
                if (sidebar.classList.contains('collapsed')) {
                    icon.classList.remove('fa-chevron-left');
                    icon.classList.add('fa-chevron-right');
                } else {
                    icon.classList.remove('fa-chevron-right');
                    icon.classList.add('fa-chevron-left');
                }
            });
            
            // 搜索功能
            const searchInput = document.getElementById('searchInput');
            const searchNav = document.getElementById('searchNav');
            const prevResultBtn = document.getElementById('prevResult');
            const nextResultBtn = document.getElementById('nextResult');
            const searchResultsCount = document.getElementById('searchResultsCount');
            const sections = document.querySelectorAll('.section');
            
            let searchResults = [];
            let currentResultIndex = -1;
            
            // 搜索输入事件
            searchInput.addEventListener('input', function() {
                const searchTerm = this.value.toLowerCase().trim();
                
                if (searchTerm === '') {
                    // 如果搜索框为空，显示所有章节并移除高亮
                    sections.forEach(section => {
                        section.style.display = 'block';
                        removeHighlight(section);
                    });
                    searchNav.classList.remove('active');
                    removeNoResultsMessage();
                    searchResults = [];
                    currentResultIndex = -1;
                    return;
                }
                
                // 执行全局搜索
                performGlobalSearch(searchTerm);
            });
            
            // 上一个结果按钮点击事件
            prevResultBtn.addEventListener('click', function() {
                if (searchResults.length === 0) return;
                
                currentResultIndex = (currentResultIndex - 1 + searchResults.length) % searchResults.length;
                scrollToSearchResult(currentResultIndex);
            });
            
            // 下一个结果按钮点击事件
            nextResultBtn.addEventListener('click', function() {
                if (searchResults.length === 0) return;
                
                currentResultIndex = (currentResultIndex + 1) % searchResults.length;
                scrollToSearchResult(currentResultIndex);
            });
            
            // 执行全局搜索函数
            function performGlobalSearch(searchTerm) {
                searchResults = [];
                currentResultIndex = -1;
                
                // 遍历所有章节，查找匹配的内容
                sections.forEach(section => {
                    const sectionText = section.textContent.toLowerCase();
                    const sectionHeading = section.querySelector('h2').textContent.toLowerCase();
                    
                    if (sectionText.includes(searchTerm) || sectionHeading.includes(searchTerm)) {
                        section.style.display = 'block';
                        
                        // 高亮匹配的文本
                        highlightText(section, searchTerm);
                        
                        // 记录所有匹配的位置
                        const matches = section.querySelectorAll('mark.highlight');
                        matches.forEach(match => {
                            searchResults.push({
                                element: match,
                                section: section
                            });
                        });
                    } else {
                        section.style.display = 'none';
                        removeHighlight(section);
                    }
                });
                
                // 更新搜索结果计数和导航按钮状态
                updateSearchNavigation();
                
                if (searchResults.length > 0) {
                    // 显示搜索导航
                    searchNav.classList.add('active');
                    
                    // 滚动到第一个匹配结果
                    currentResultIndex = 0;
                    scrollToSearchResult(0);
                    
                    removeNoResultsMessage();
                } else {
                    // 隐藏搜索导航
                    searchNav.classList.remove('active');
                    
                    // 显示无结果提示信息
                    showNoResultsMessage();
                }
            }
            
            // 更新搜索导航状态
            function updateSearchNavigation() {
                if (searchResults.length === 0) {
                    searchResultsCount.textContent = '0/0';
                    prevResultBtn.disabled = true;
                    nextResultBtn.disabled = true;
                } else {
                    searchResultsCount.textContent = `${currentResultIndex + 1}/${searchResults.length}`;
                    prevResultBtn.disabled = false;
                    nextResultBtn.disabled = false;
                }
            }
            
            // 滚动到搜索结果
            function scrollToSearchResult(index) {
                if (index < 0 || index >= searchResults.length) return;
                
                const result = searchResults[index];
                const element = result.element;
                
                // 确保包含结果的章节是可见的
                result.section.style.display = 'block';
                
                // 计算元素位置并滚动
                const elementPosition = element.getBoundingClientRect().top + window.pageYOffset;
                
                // 延迟滚动以确保DOM更新完成
                setTimeout(() => {
                    window.scrollTo({
                        top: elementPosition - 100, // 减去header高度
                        behavior: 'smooth'
                    });
                    
                    // 更新当前结果索引和计数
                    currentResultIndex = index;
                    updateSearchNavigation();
                    
                    // 临时高亮当前结果
                    highlightCurrentResult(element);
                }, 100);
            }
            
            // 高亮当前结果
            function highlightCurrentResult(element) {
                // 移除所有当前结果高亮
                document.querySelectorAll('.current-search-result').forEach(el => {
                    el.classList.remove('current-search-result');
                });
                
                // 添加当前结果高亮
                element.classList.add('current-search-result');
                
                // 3秒后移除高亮
                setTimeout(() => {
                    element.classList.remove('current-search-result');
                }, 3000);
            }
            
            // 高亮文本函数
            function highlightText(element, searchTerm) {
                removeHighlight(element);
                
                if (!searchTerm) return;
                
                const regex = new RegExp(`(${searchTerm})`, 'gi');
                const walker = document.createTreeWalker(
                    element,
                    NodeFilter.SHOW_TEXT,
                    null,
                    false
                );
                
                const textNodes = [];
                while (walker.nextNode()) {
                    textNodes.push(walker.currentNode);
                }
                
                textNodes.forEach(node => {
                    const text = node.textContent;
                    if (regex.test(text)) {
                        const span = document.createElement('span');
                        span.innerHTML = text.replace(regex, '<mark class="highlight">$1</mark>');
                        node.parentNode.replaceChild(span, node);
                    }
                });
            }
            
            // 移除高亮函数
            function removeHighlight(element) {
                const highlights = element.querySelectorAll('mark.highlight');
                highlights.forEach(highlight => {
                    const parent = highlight.parentNode;
                    parent.replaceChild(document.createTextNode(highlight.textContent), highlight);
                    parent.normalize();
                });
            }
            
            // 显示无结果提示信息
            function showNoResultsMessage() {
                const content = document.getElementById('content');
                
                // 检查是否已经存在提示信息
                let noResultsMsg = document.getElementById('no-results-message');
                if (!noResultsMsg) {
                    noResultsMsg = document.createElement('div');
                    noResultsMsg.id = 'no-results-message';
                    noResultsMsg.className = 'section';
                    noResultsMsg.innerHTML = '<h2>搜索结果</h2><p>没有找到与搜索词相关的内容。</p>';
                    content.appendChild(noResultsMsg);
                }
                
                // 隐藏所有章节，只显示提示信息
                sections.forEach(section => {
                    section.style.display = 'none';
                });
                noResultsMsg.style.display = 'block';
            }
            
            // 移除无结果提示信息
            function removeNoResultsMessage() {
                const noResultsMsg = document.getElementById('no-results-message');
                if (noResultsMsg) {
                    noResultsMsg.remove();
                }
            }
            
            // 移动端菜单切换
            menuToggle.addEventListener('click', function() {
                sidebar.classList.toggle('active');
                navOverlay.classList.toggle('active');
            });
            
            navOverlay.addEventListener('click', function() {
                sidebar.classList.remove('active');
                navOverlay.classList.remove('active');
            });
            
            // 侧边栏链接点击事件
            const sidebarLinks = sidebar.querySelectorAll('a');
            sidebarLinks.forEach(link => {
                link.addEventListener('click', function() {
                    // 移除所有active类
                    sidebarLinks.forEach(l => l.classList.remove('active'));
                    // 添加active类到当前链接
                    this.classList.add('active');
                    
                    // 在移动设备上关闭侧边栏
                    if (window.innerWidth <= 992) {
                        sidebar.classList.remove('active');
                        navOverlay.classList.remove('active');
                    }
                });
            });
            
            // 平滑滚动
            document.querySelectorAll('a[href^="#"]').forEach(anchor => {
                anchor.addEventListener('click', function(e) {
                    e.preventDefault();
                    
                    const targetId = this.getAttribute('href');
                    if (targetId === '#') return;
                    
                    const targetElement = document.querySelector(targetId);
                    if (targetElement) {
                        window.scrollTo({
                            top: targetElement.offsetTop - 80,
                            behavior: 'smooth'
                        });
                    }
                });
            });
            
            // 滚动时更新活动链接
            window.addEventListener('scroll', function() {
                const sections = document.querySelectorAll('.section');
                const scrollPosition = window.scrollY + 100;
                
                sections.forEach(section => {
                    const sectionTop = section.offsetTop;
                    const sectionHeight = section.offsetHeight;
                    const sectionId = section.getAttribute('id');
                    
                    if (scrollPosition >= sectionTop && scrollPosition < sectionTop + sectionHeight) {
                        sidebarLinks.forEach(link => {
                            link.classList.remove('active');
                            if (link.getAttribute('href') === `#${sectionId}`) {
                                link.classList.add('active');
                            }
                        });
                    }
                });
            });
        });
        
        // 复制代码功能
        function copyCode(button) {
            const codeBlock = button.nextElementSibling;
            const code = codeBlock.textContent;
            
            // 创建临时文本区域
            const textArea = document.createElement('textarea');
            textArea.value = code;
            document.body.appendChild(textArea);
            textArea.select();
            
            try {
                // 执行复制命令
                document.execCommand('copy');
                
                // 更新按钮文本
                button.textContent = '已复制';
                button.classList.add('copied');
                
                // 2秒后恢复按钮文本
                setTimeout(() => {
                    button.textContent = '复制';
                    button.classList.remove('copied');
                }, 2000);
            } catch (err) {
                console.error('复制失败:', err);
            }
            
            // 移除临时文本区域
            document.body.removeChild(textArea);
        }
        
        // 检查答案功能
        function checkAnswer(questionId, correctAnswer) {
            const options = document.getElementsByName(questionId);
            const feedback = document.getElementById(`${questionId}-feedback`);
            
            let selectedAnswer = null;
            for (const option of options) {
                if (option.checked) {
                    selectedAnswer = option.value;
                    break;
                }
            }
            
            if (selectedAnswer === null) {
                feedback.textContent = '请选择一个答案。';
                feedback.className = 'quiz-feedback incorrect';
                feedback.style.display = 'block';
                return;
            }
            
            if (selectedAnswer === correctAnswer) {
                feedback.textContent = '回答正确！';
                feedback.className = 'quiz-feedback correct';
            } else {
                feedback.textContent = '回答错误，请再试一次。';
                feedback.className = 'quiz-feedback incorrect';
            }
            
            feedback.style.display = 'block';
        }
    </script>
</body>
</html>